{
\\ The constants 76938, 120 and 736 below are chosen based on the bound of \\
\\ 4*10^14 to provide a large enough vector of small primes, p, and P and Q \\
\\ products such that any candidate values must share at least 4 prime factors \\
\\ with P and 6 with P*Q--at initialization, as factors move between P and Q \\
\\ as the product of smallest 4 primes, k1, changes. The vector d fixes the \\
\\ offset between the product having divisor k1 and the right neighbors, as \\
\\ this product changes modulo 4. The 4th smallest prime runs from the 8th to \\
\\ 79th to meet the requirements that the product of 4 smallest may be larger \\
\\ than the similar products of its putative trio partners and the whole product \\
\\ is less than the specific bound B.  The constant 20552 is one less than \\
\\ A260075(4). In the first stage the indices of this product of 4 smallest are \\
\\ set, with P and Q changing with its changes; then each successively larger of \\
\\ the remaining 4 prime factors are set with bounds determined using variables \\
\\ r, s, t and u (in a clear way). After the trio partners a and b are determined, \\
\\ the candidate nature is tested first for if enough prime factors are held in \\
\\ common with both and P, and duplication of effort avoided by ensuring neither \\
\\ has larger product of smallest 4 primes than the product we know.  Then if both \\
\\ values pass further tests that the primes in common with P are not raised to a \\
\\ power in either--by splitting a and b into the smaller and larger parts a1 and a2 \\
\\ and b1 and b2--use is made of variables y and z for the numbers of prime factors in \\
\\ common with P*Q (y1 and z1 already having been used for those with just P) to test \\
\\ the requirement this be a value from 6 through 8. To this end the variables a2 and b2 \\
\\ are further split into parts a21 and a22 and b21 and b22 (with testing that the \\
\\ values are finally certainly squarefree).  Only after having passed through these \\
\\ smaller tests are the qualifying nature of the numbers completely tested by determining \\
\\ if the right number of distinct prime factors are held by the residual parts a22 and b22. \\
\\ If this turns out to be so, because of the necessary sizes of any remaining primes no \\ 
\\ further testing is necessary and the middle value of is printed.  In this version, extra \\
\\ characters are printed to mark progress.  The product K is managed individual known factor \\
\\ at a time (with the divisions seen at the end matched to multiplications at the beginning). \\
   
p=vector(76938,n,prime(n));P=prod(i=1,120,p[i]);Q=prod(i=121,736,p[i]);v=121;
d=[[1,2],[-1,1],[-2,-1]];B=4*10^14;i4=8;p4=vector(79,n,prod(i=1,4,p[n+i]));
while(i4<80,k1=p[i4];
 for(i3=3,i4-1,k1*=p[i3];
  for(i2=2,i3-1,k1*=p[i2];
   for(i1=1,i2-1,k1*=p[i1];
    if(k1>20552,if(k1*p4[i4]<B,
     if(30*p[v-1]<k1,
      while(30*p[v]<k1,Q/=p[v];P*=p[v];v++),
      while(30*p[v-1]>=k1,v--;Q*=p[v];P/=p[v]));
     r=(B\k1)^(1/4);j1=i4+1;
     while(p[j1]<r,
      k2=p[j1]*k1;s=(B\k2)^(1/3);j2=j1+1;
      while(p[j2]<s,
       k3=p[j2]*k2;t=sqrt(B\k3);j3=j2+1;
       while(p[j3]<t,
        k4=p[j3]*k3;j4=j3+1;u=B\k4;
        while(p[j4]<=u,
         K=k4*p[j4];a=K+d[K%4][1];b=K+d[K%4][2];
         a1=gcd(P,a);y1=omega(a1);
         if(y1>3,f=1;if(y1==4,if(a1>k1,f=0));
          if(f,
           b1=gcd(P,b);z1=omega(b1);
           if(z1>3,
            if(z1==4,if(b1>k1,f=0));
            if(f,
             a2=a/a1;if(gcd(a1,a2)==1,
              b2=b/b1;if(gcd(b1,b2)==1,
               a21=gcd(a2,Q);a22=a2/a21;
               if(gcd(a21,a22)==1,
                y=y1+omega(a21);
                if(y>5,if(y<9,
                  b21=gcd(b2,Q);b22=b2/b21;
                  if(gcd(b21,b22)==1,
                   z=z1+omega(b21);
                   if(z>5,if(z<9,
                     if(y+omega(a22)==8,
                      if(z+omega(b22)==8,
                       print1((K\4)*4+2" ")))))))))))))));
         j4++);
        j3++);
       j2++);
      j1++)));
   k1/=p[i1]);
  k1/=p[i2]);
 k1/=p[i3];print1("*"));
i4++;print1("&"))

}